home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Magazine / Guru / Samba / source / amiga.diffs next >
Encoding:
Text File  |  2000-08-17  |  27.2 KB  |  1,175 lines
  1. *** lib/system.c    Tue Apr 25 20:06:52 2000
  2. --- /new/lib/system.c    Mon May 22 19:02:10 2000
  3. ***************
  4. *** 795,955 ****
  5.   
  6.   FILE *sys_popen(const char *command, const char *mode, BOOL paranoid)
  7.   {
  8. !     int parent_end, child_end;
  9. !     int pipe_fds[2];
  10. !     popen_list *entry = NULL;
  11. !     char **argl = NULL;
  12. ! 
  13. !     if (pipe(pipe_fds) < 0)
  14. !         return NULL;
  15. ! 
  16. !     if (mode[0] == 'r' && mode[1] == '\0') {
  17. !         parent_end = pipe_fds[0];
  18. !         child_end = pipe_fds[1];
  19. !     } else if (mode[0] == 'w' && mode[1] == '\0') {
  20. !         parent_end = pipe_fds[1];
  21. !         child_end = pipe_fds[0];
  22. !     } else {
  23. !         errno = EINVAL;
  24. !         goto err_exit;
  25. !     }
  26. ! 
  27. !     if (!*command) {
  28. !         errno = EINVAL;
  29. !         goto err_exit;
  30.       }
  31.   
  32. !     if((entry = (popen_list *)malloc(sizeof(popen_list))) == NULL)
  33. !         goto err_exit;
  34. ! 
  35. !     /*
  36. !      * Extract the command and args into a NULL terminated array.
  37. !      */
  38.   
  39. !     if(!(argl = extract_args(command)))
  40. !         goto err_exit;
  41.   
  42. -     if(paranoid) {
  43.           /*
  44. !          * Do some basic paranioa checks. Do a stat on the parent
  45. !          * directory and ensure it's not world writable. Do a stat
  46. !          * on the file itself and ensure it's owned by root and not
  47. !          * world writable. Note this does *not* prevent symlink races,
  48. !          * but is a generic "don't let the admin screw themselves"
  49. !          * check.
  50.            */
  51.   
  52. !         SMB_STRUCT_STAT st;
  53. !         pstring dir_name;
  54. !         char *ptr = strrchr(argl[0], '/');
  55. !     
  56. !         if(sys_stat(argl[0], &st) != 0)
  57.               goto err_exit;
  58.   
  59. !         if((st.st_uid != (uid_t)0) || (st.st_mode & S_IWOTH)) {
  60. !             errno = EACCES;
  61. !             goto err_exit;
  62. !         }
  63. !         
  64. !         if(!ptr) {
  65.               /*
  66. !              * No '/' in name - use current directory.
  67.                */
  68. -             pstrcpy(dir_name, ".");
  69. -         } else {
  70.   
  71. !             /*
  72. !              * Copy into a pstring and do the checks
  73. !              * again (in case we were length tuncated).
  74. !              */
  75.   
  76. !             pstrcpy(dir_name, argl[0]);
  77. !             ptr = strrchr(dir_name, '/');
  78. !             if(!ptr) {
  79. !                 errno = EINVAL;
  80.                   goto err_exit;
  81.               }
  82. !             if(strcmp(dir_name, "/") != 0)
  83. !                 *ptr = '\0';
  84. !             if(!dir_name[0])
  85.                   pstrcpy(dir_name, ".");
  86.           }
  87.   
  88. !         if(sys_stat(argl[0], &st) != 0)
  89. !             goto err_exit;
  90.   
  91. -         if(!S_ISDIR(st.st_mode) || (st.st_mode & S_IWOTH)) {
  92. -             errno = EACCES;
  93.               goto err_exit;
  94.           }
  95. -     }
  96.   
  97. !     entry->child_pid = fork();
  98.   
  99. !     if (entry->child_pid == -1) {
  100. ! 
  101. !         /*
  102. !          * Error !
  103. !          */
  104.   
  105. !         goto err_exit;
  106. !     }
  107.   
  108. !     if (entry->child_pid == 0) {
  109.   
  110. !         /*
  111. !          * Child !
  112. !          */
  113.   
  114. !         int child_std_end = (mode[0] == 'r') ? STDOUT_FILENO : STDIN_FILENO;
  115. !         popen_list *p;
  116.   
  117. !         close(parent_end);
  118. !         if (child_end != child_std_end) {
  119. !             dup2 (child_end, child_std_end);
  120. !             close (child_end);
  121.           }
  122.   
  123.           /*
  124. !          * POSIX.2:  "popen() shall ensure that any streams from previous
  125. !          * popen() calls that remain open in the parent process are closed
  126. !          * in the new child process."
  127.            */
  128.   
  129. !         for (p = popen_chain; p; p = p->next)
  130. !             close(fileno(p->fp));
  131. ! 
  132. !         execv(argl[0], argl);
  133. !         _exit (127);
  134. !     }
  135. ! 
  136. !     /*
  137. !      * Parent.
  138. !      */
  139. ! 
  140. !     close (child_end);
  141. !     free((char *)argl);
  142. ! 
  143. !     /*
  144. !      * Create the FILE * representing this fd.
  145. !      */
  146. !     entry->fp = fdopen(parent_end, mode);
  147. ! 
  148. !     /* Link into popen_chain. */
  149. !     entry->next = popen_chain;
  150. !     popen_chain = entry;
  151. ! 
  152. !     return entry->fp;
  153.   
  154. ! err_exit:
  155.   
  156. !     if(entry)
  157. !         free((char *)entry);
  158. !     if(argl)
  159. !         free((char *)argl);
  160. !     close(pipe_fds[0]);
  161. !     close(pipe_fds[1]);
  162. !     return NULL;
  163.   }
  164.   
  165.   /**************************************************************************
  166. --- 795,963 ----
  167.   
  168.   FILE *sys_popen(const char *command, const char *mode, BOOL paranoid)
  169.   {
  170. !     #ifdef AMIGA
  171. !     {
  172. !         return( amiga_popen(command,mode) );
  173.       }
  174. +     #else
  175. +     {
  176. +         int parent_end, child_end;
  177. +         int pipe_fds[2];
  178. +         popen_list *entry = NULL;
  179. +         char **argl = NULL;
  180. + 
  181. +         if (pipe(pipe_fds) < 0)
  182. +             return NULL;
  183. + 
  184. +         if (mode[0] == 'r' && mode[1] == '\0') {
  185. +             parent_end = pipe_fds[0];
  186. +             child_end = pipe_fds[1];
  187. +            } else if (mode[0] == 'w' && mode[1] == '\0') {
  188. +             parent_end = pipe_fds[1];
  189. +             child_end = pipe_fds[0];
  190. +         } else {
  191. +             errno = EINVAL;
  192. +             goto err_exit;
  193. +         }
  194.   
  195. !         if (!*command) {
  196. !             errno = EINVAL;
  197. !             goto err_exit;
  198. !         }
  199.   
  200. !         if((entry = (popen_list *)malloc(sizeof(popen_list))) == NULL)
  201. !             goto err_exit;
  202.   
  203.           /*
  204. !          * Extract the command and args into a NULL terminated array.
  205.            */
  206.   
  207. !         if(!(argl = extract_args(command)))
  208.               goto err_exit;
  209.   
  210. !         if(paranoid) {
  211.               /*
  212. !              * Do some basic paranioa checks. Do a stat on the parent
  213. !              * directory and ensure it's not world writable. Do a stat
  214. !              * on the file itself and ensure it's owned by root and not
  215. !              * world writable. Note this does *not* prevent symlink races,
  216. !              * but is a generic "don't let the admin screw themselves"
  217. !              * check.
  218.                */
  219.   
  220. !             SMB_STRUCT_STAT st;
  221. !             pstring dir_name;
  222. !             char *ptr = strrchr(argl[0], '/');
  223. !         
  224. !             if(sys_stat(argl[0], &st) != 0)
  225. !                 goto err_exit;
  226.   
  227. !             if((st.st_uid != (uid_t)0) || (st.st_mode & S_IWOTH)) {
  228. !                 errno = EACCES;
  229.                   goto err_exit;
  230.               }
  231. !             
  232. !             if(!ptr) {
  233. !                 /*
  234. !                  * No '/' in name - use current directory.
  235. !                  */
  236.                   pstrcpy(dir_name, ".");
  237. +             } else {
  238. + 
  239. +                 /*
  240. +                  * Copy into a pstring and do the checks
  241. +                  * again (in case we were length tuncated).
  242. +                  */
  243. + 
  244. +                 pstrcpy(dir_name, argl[0]);
  245. +                 ptr = strrchr(dir_name, '/');
  246. +                 if(!ptr) {
  247. +                     errno = EINVAL;
  248. +                     goto err_exit;
  249. +                 }
  250. +                 if(strcmp(dir_name, "/") != 0)
  251. +                     *ptr = '\0';
  252. +                 if(!dir_name[0])
  253. +                     pstrcpy(dir_name, ".");
  254. +             }
  255. + 
  256. +             if(sys_stat(argl[0], &st) != 0)
  257. +                 goto err_exit;
  258. + 
  259. +             if(!S_ISDIR(st.st_mode) || (st.st_mode & S_IWOTH)) {
  260. +                 errno = EACCES;
  261. +                 goto err_exit;
  262. +             }
  263.           }
  264.   
  265. !         entry->child_pid = fork();
  266. ! 
  267. !         if (entry->child_pid == -1) {
  268. ! 
  269. !             /*
  270. !              * Error !
  271. !              */
  272.   
  273.               goto err_exit;
  274.           }
  275.   
  276. !         if (entry->child_pid == 0) {
  277.   
  278. !             /*
  279. !              * Child !
  280. !              */
  281.   
  282. !             int child_std_end = (mode[0] == 'r') ? STDOUT_FILENO : STDIN_FILENO;
  283. !             popen_list *p;
  284.   
  285. !             close(parent_end);
  286. !             if (child_end != child_std_end) {
  287. !                 dup2 (child_end, child_std_end);
  288. !                 close (child_end);
  289. !             }
  290.   
  291. !             /*
  292. !              * POSIX.2:  "popen() shall ensure that any streams from previous
  293. !              * popen() calls that remain open in the parent process are closed
  294. !              * in the new child process."
  295. !              */
  296.   
  297. !             for (p = popen_chain; p; p = p->next)
  298. !                 close(fileno(p->fp));
  299.   
  300. !             execv(argl[0], argl);
  301. !             _exit (127);
  302.           }
  303.   
  304.           /*
  305. !          * Parent.
  306.            */
  307.   
  308. !         close (child_end);
  309. !         free((char *)argl);
  310.   
  311. !         /*
  312. !          * Create the FILE * representing this fd.
  313. !          */
  314. !         entry->fp = fdopen(parent_end, mode);
  315.   
  316. !         /* Link into popen_chain. */
  317. !         entry->next = popen_chain;
  318. !         popen_chain = entry;
  319. ! 
  320. !         return entry->fp;
  321. ! 
  322. !     err_exit:
  323. ! 
  324. !         if(entry)
  325. !             free((char *)entry);
  326. !         if(argl)
  327. !             free((char *)argl);
  328. !         close(pipe_fds[0]);
  329. !         close(pipe_fds[1]);
  330. !         return NULL;
  331. !     }
  332. !     #endif /* AMIGA */
  333.   }
  334.   
  335.   /**************************************************************************
  336. ***************
  337. *** 958,995 ****
  338.   
  339.   int sys_pclose( FILE *fp)
  340.   {
  341. !     int wstatus;
  342. !     popen_list **ptr = &popen_chain;
  343. !     popen_list *entry = NULL;
  344. !     pid_t wait_pid;
  345. !     int status = -1;
  346. ! 
  347. !     /* Unlink from popen_chain. */
  348. !     for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
  349. !         if ((*ptr)->fp == fp) {
  350. !             entry = *ptr;
  351. !             *ptr = (*ptr)->next;
  352. !             status = 0;
  353. !             break;
  354. !         }
  355.       }
  356.   
  357. !     if (status < 0 || close(fileno(entry->fp)) < 0)
  358. !         return -1;
  359.   
  360. !     /*
  361. !      * As Samba is catching and eating child process
  362. !      * exits we don't really care about the child exit
  363. !      * code, a -1 with errno = ECHILD will do fine for us.
  364. !      */
  365. ! 
  366. !     do {
  367. !         wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
  368. !     } while (wait_pid == -1 && errno == EINTR);
  369. ! 
  370. !     free((char *)entry);
  371. ! 
  372. !     if (wait_pid == -1)
  373. !         return -1;
  374. !     return wstatus;
  375.   }
  376. --- 966,1012 ----
  377.   
  378.   int sys_pclose( FILE *fp)
  379.   {
  380. !     #ifdef AMIGA
  381. !     {
  382. !         return( amiga_pclose(fp) );
  383.       }
  384. +     #else
  385. +     {
  386. +         int wstatus;
  387. +         popen_list **ptr = &popen_chain;
  388. +         popen_list *entry = NULL;
  389. +         pid_t wait_pid;
  390. +         int status = -1;
  391. + 
  392. +         /* Unlink from popen_chain. */
  393. +         for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
  394. +             if ((*ptr)->fp == fp) {
  395. +                 entry = *ptr;
  396. +                 *ptr = (*ptr)->next;
  397. +                 status = 0;
  398. +                 break;
  399. +             }
  400. +         }
  401.   
  402. !         if (status < 0 || close(fileno(entry->fp)) < 0)
  403. !             return -1;
  404.   
  405. !         /*
  406. !          * As Samba is catching and eating child process
  407. !          * exits we don't really care about the child exit
  408. !          * code, a -1 with errno = ECHILD will do fine for us.
  409. !          */
  410. ! 
  411. !         do {
  412. !             wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
  413. !         } while (wait_pid == -1 && errno == EINTR);
  414. ! 
  415. !         free((char *)entry);
  416. ! 
  417. !         if (wait_pid == -1)
  418. !             return -1;
  419. ! 
  420. !         return wstatus;
  421. !     }
  422. !     #endif /* AMIGA */
  423.   }
  424. *** lib/snprintf.c    Tue Apr 25 20:06:52 2000
  425. --- /new/lib/snprintf.c    Thu Aug 17 14:04:03 2000
  426. ***************
  427. *** 49,54 ****
  428. --- 49,59 ----
  429.    *    fixed handling of %.0f
  430.    *    added test for HAVE_LONG_DOUBLE
  431.    *
  432. +  *  Olaf Barthel <olsen@sourcery.han.de> 15-Oct-99
  433. +  *    Implemented the missing 'f' and 'g' floating point output
  434. +  *    formats; also fixed handling of floating point numbers
  435. +  *    like "0.01" which would always come out as "0.1".
  436. +  *
  437.    **************************************************************/
  438.   
  439.   #include "config.h"
  440. ***************
  441. *** 59,64 ****
  442. --- 64,73 ----
  443.   
  444.   #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
  445.   
  446. + #ifdef AMIGA
  447. + #include <math.h>
  448. + #endif /* AMIGA */
  449. + 
  450.   /* Define this as a fall through, HAVE_STDARG_H is probably already set */
  451.   
  452.   #define HAVE_VARARGS_H
  453. ***************
  454. *** 107,113 ****
  455.   static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
  456.               long value, int base, int min, int max, int flags);
  457.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  458. !            LDOUBLE fvalue, int min, int max, int flags);
  459.   static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
  460.   
  461.   /*
  462. --- 116,122 ----
  463.   static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
  464.               long value, int base, int min, int max, int flags);
  465.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  466. !            LDOUBLE fvalue, int min, int max, int flags, char ch);
  467.   static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
  468.   
  469.   /*
  470. ***************
  471. *** 326,332 ****
  472.       else
  473.         fvalue = va_arg (args, double);
  474.       /* um, floating point? */
  475. !     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
  476.       break;
  477.         case 'E':
  478.       flags |= DP_F_UP;
  479. --- 335,341 ----
  480.       else
  481.         fvalue = va_arg (args, double);
  482.       /* um, floating point? */
  483. !     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  484.       break;
  485.         case 'E':
  486.       flags |= DP_F_UP;
  487. ***************
  488. *** 335,340 ****
  489. --- 344,351 ----
  490.         fvalue = va_arg (args, LDOUBLE);
  491.       else
  492.         fvalue = va_arg (args, double);
  493. +     /* um, floating point? */
  494. +     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  495.       break;
  496.         case 'G':
  497.       flags |= DP_F_UP;
  498. ***************
  499. *** 343,348 ****
  500. --- 354,361 ----
  501.         fvalue = va_arg (args, LDOUBLE);
  502.       else
  503.         fvalue = va_arg (args, double);
  504. +     /* um, floating point? */
  505. +     fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags, ch);
  506.       break;
  507.         case 'c':
  508.       dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
  509. ***************
  510. *** 577,584 ****
  511.   }
  512.   
  513.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  514. !            LDOUBLE fvalue, int min, int max, int flags)
  515.   {
  516.     int signvalue = 0;
  517.     LDOUBLE ufvalue;
  518.   #ifndef HAVE_FCVT
  519. --- 590,604 ----
  520.   }
  521.   
  522.   static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
  523. !            LDOUBLE fvalue, int min, int max, int flags, char ch)
  524.   {
  525. +   enum /* olsen: output formats to be used below. */
  526. +   {
  527. +     FORMAT_f,
  528. +     FORMAT_g,
  529. +     FORMAT_e
  530. +   };
  531. + 
  532.     int signvalue = 0;
  533.     LDOUBLE ufvalue;
  534.   #ifndef HAVE_FCVT
  535. ***************
  536. *** 593,599 ****
  537. --- 613,621 ----
  538.   # ifdef HAVE_FCVTL
  539.     extern char *fcvtl(long double value, int ndigit, int *decpt, int *sign);
  540.   # else
  541. + #ifndef AMIGA
  542.     extern char *fcvt(double value, int ndigit, int *decpt, int *sign);
  543. + #endif /* AMIGA */
  544.   # endif
  545.   #endif
  546.     int iplace = 0;
  547. ***************
  548. *** 603,609 ****
  549.     int caps = 0;
  550.     long intpart;
  551.     long fracpart;
  552. !   
  553.     /* 
  554.      * AIX manpage says the default is 0, but Solaris says the default
  555.      * is 6, and sprintf on AIX defaults to 6
  556. --- 625,635 ----
  557.     int caps = 0;
  558.     long intpart;
  559.     long fracpart;
  560. !   int exponent;
  561. !   int exponentLen;
  562. !   int outputFmt;
  563. !   int decimalPointLen;
  564. ! 
  565.     /* 
  566.      * AIX manpage says the default is 0, but Solaris says the default
  567.      * is 6, and sprintf on AIX defaults to 6
  568. ***************
  569. *** 622,627 ****
  570. --- 648,696 ----
  571.         if (flags & DP_F_SPACE)
  572.       signvalue = ' ';
  573.   
  574. +   /* olsen: determine the output format. */
  575. +   if(ch == 'g' || ch == 'G')
  576. +     outputFmt = FORMAT_g;
  577. +   else if (ch == 'e' || ch == 'E')
  578. +     outputFmt = FORMAT_e;
  579. +   else
  580. +     outputFmt = FORMAT_f;
  581. + 
  582. +   /* olsen: calculate the exponent */
  583. +   exponent = 0;
  584. +   if(ufvalue > 0.0 && outputFmt != FORMAT_f)
  585. +   {
  586. +     LDOUBLE value = ufvalue;
  587. + 
  588. +     /* Make sure that the integer part
  589. +      * comes out as a single digit.
  590. +      */
  591. +     if(value < 1.0)
  592. +     {
  593. +       do
  594. +       {
  595. +         value *= 10.0;
  596. +         exponent--;
  597. +       }
  598. +       while(value < 1.0);
  599. +     }
  600. +     else if(value > 10.0)
  601. +     {
  602. +       do
  603. +       {
  604. +         value /= 10.0;
  605. +         exponent++;
  606. +       }
  607. +       while(value > 10.0);
  608. +     }
  609. + 
  610. +     /* Don't change the base unless we are to output
  611. +      * the number in scientific format.
  612. +      */
  613. +     if((outputFmt == FORMAT_e) || (outputFmt == FORMAT_g && exponent < -4))
  614. +       ufvalue = value;
  615. +   }
  616. + 
  617.   #if 0
  618.     if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
  619.   #endif
  620. ***************
  621. *** 659,674 ****
  622.       intpart = (intpart / 10);
  623.     } while(intpart && (iplace < 20));
  624.     if (iplace == 20) iplace--;
  625. !   iconvert[iplace] = 0;
  626.   
  627.     /* Convert fractional part */
  628.     do {
  629.       fconvert[fplace++] =
  630.         (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
  631.       fracpart = (fracpart / 10);
  632. !   } while(fracpart && (fplace < 20));
  633.     if (fplace == 20) fplace--;
  634. !   fconvert[fplace] = 0;
  635.   #else  /* use fcvt() */
  636.     if (max > 310)
  637.       max = 310;
  638. --- 728,752 ----
  639.       intpart = (intpart / 10);
  640.     } while(intpart && (iplace < 20));
  641.     if (iplace == 20) iplace--;
  642. !   iconvert[iplace] = '\0';
  643.   
  644.     /* Convert fractional part */
  645.     do {
  646.       fconvert[fplace++] =
  647.         (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
  648.       fracpart = (fracpart / 10);
  649. !   } while(fracpart != 0 && (fplace < 20));
  650. ! 
  651. !   /* olsen: we need to make up for numbers like 0.01
  652. !    *        which would come out as "0.1" unless
  653. !    *        we add a few padding zeroes.
  654. !    */
  655. !   while(fplace < 20 && fplace < max)
  656. !     fconvert[fplace++] = '0';
  657. ! 
  658.     if (fplace == 20) fplace--;
  659. !   fconvert[fplace] = '\0';
  660. ! 
  661.   #else  /* use fcvt() */
  662.     if (max > 310)
  663.       max = 310;
  664. ***************
  665. *** 724,731 ****
  666.     }
  667.   #endif /* fcvt */
  668.     
  669.     /* -1 for decimal point, another -1 if we are printing a sign */
  670. !   padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
  671.     zpadlen = max - fplace;
  672.     if (zpadlen < 0)
  673.       zpadlen = 0;
  674. --- 802,871 ----
  675.     }
  676.   #endif /* fcvt */
  677.     
  678. +   /* olsen: eliminate trailing zeroes. */
  679. +   decimalPointLen = (max > 0) ? 1 : 0;
  680. +   exponentLen = 0;
  681. +   if(outputFmt == FORMAT_g)
  682. +   {
  683. +     int i,numTrailingZeroes;
  684. + 
  685. +     /* Count the number of trailing zeroes. */
  686. +     numTrailingZeroes = 0;
  687. +     for(i = 0 ; i < fplace ; i++)
  688. +     {
  689. +       if(fconvert[i] == '0')
  690. +         numTrailingZeroes++;
  691. +       else
  692. +         break;
  693. +     }
  694. + 
  695. +     /* If there are any, remove them. */
  696. +     if(numTrailingZeroes > 0)
  697. +     {
  698. +       /* Remove the zeroes, if necessary.
  699. +        * Otherwise, just forget that we
  700. +        * had any digits in the fractional
  701. +        * part.
  702. +        */
  703. +       if(numTrailingZeroes != fplace)
  704. +       {
  705. +         for(i = 0 ; i < fplace-numTrailingZeroes ; i++)
  706. +           fconvert[i] = fconvert[numTrailingZeroes+i];
  707. +       }
  708. + 
  709. +       fplace -= numTrailingZeroes;
  710. +       fconvert[fplace] = '\0';
  711. + 
  712. +       /* Don't print the decimal point if
  713. +        * there is nothing to follow it.
  714. +        */
  715. +       if(fplace == 0)
  716. +         decimalPointLen = 0;
  717. +     }
  718. + 
  719. +     /* Switch to scientific output format
  720. +      * if the exponent is too small.
  721. +      */
  722. +     if(exponent < -4)
  723. +     {
  724. +       /* Two digits for the "e+" and
  725. +        * at least two digits for the number
  726. +        * to follow the sign.
  727. +        */
  728. +       exponentLen = (int)log10((LDOUBLE)exponent) + 2;
  729. +       if(exponentLen < 4)
  730. +         exponentLen = 4;
  731. +     }
  732. +   }
  733. +   else if(outputFmt == FORMAT_e)
  734. +   {
  735. +     exponentLen = (int)log10((LDOUBLE)exponent) + 2;
  736. +     if(exponentLen < 4)
  737. +       exponentLen = 4;
  738. +   }
  739. + 
  740.     /* -1 for decimal point, another -1 if we are printing a sign */
  741. !   padlen = min - iplace - max - decimalPointLen - ((signvalue) ? 1 : 0); 
  742.     zpadlen = max - fplace;
  743.     if (zpadlen < 0)
  744.       zpadlen = 0;
  745. ***************
  746. *** 734,739 ****
  747. --- 874,883 ----
  748.     if (flags & DP_F_MINUS) 
  749.       padlen = -padlen; /* Left Justifty */
  750.   
  751. +   /* olsen: eliminate trailing zeroes. */
  752. +   if(outputFmt == FORMAT_g)
  753. +     zpadlen = 0;
  754. + 
  755.     if ((flags & DP_F_ZERO) && (padlen > 0)) 
  756.     {
  757.       if (signvalue) 
  758. ***************
  759. *** 768,774 ****
  760.      * Decimal point.  This should probably use locale to find the correct
  761.      * char to print out.
  762.      */
  763. !   if (max > 0) {
  764.         dopr_outch (buffer, currlen, maxlen, '.');
  765.   
  766.         while (fplace > 0) 
  767. --- 912,918 ----
  768.      * Decimal point.  This should probably use locale to find the correct
  769.      * char to print out.
  770.      */
  771. !   if (max > 0 && decimalPointLen > 0) {
  772.         dopr_outch (buffer, currlen, maxlen, '.');
  773.   
  774.         while (fplace > 0) 
  775. ***************
  776. *** 781,786 ****
  777. --- 925,959 ----
  778.       --zpadlen;
  779.     }
  780.   
  781. +   /* olsen: output the exponent */
  782. +   if(exponentLen > 0)
  783. +   {
  784. +     char expChars[10];
  785. +     int numExpChars;
  786. +     int i;
  787. + 
  788. +     dopr_outch (buffer, currlen, maxlen, caps?'E':'e');
  789. +     if(exponent < 0)
  790. +     {
  791. +       dopr_outch (buffer, currlen, maxlen, '-');
  792. +       exponent = (-exponent);
  793. +     }
  794. +     else
  795. +     {
  796. +       dopr_outch (buffer, currlen, maxlen, '+');
  797. +     }
  798. + 
  799. +     numExpChars = 0;
  800. +     for(i = 0 ; i < exponentLen-2 && i < sizeof(expChars)-1 ; i++)
  801. +     {
  802. +       expChars[numExpChars++] = '0' + (exponent % 10);
  803. +       exponent /= 10;
  804. +     }
  805. + 
  806. +     while(numExpChars > 0)
  807. +       dopr_outch (buffer, currlen, maxlen, expChars[--numExpChars]);
  808. +   }
  809. + 
  810.     while (padlen < 0) 
  811.     {
  812.       dopr_outch (buffer, currlen, maxlen, ' ');
  813. ***************
  814. *** 856,861 ****
  815. --- 1029,1063 ----
  816.       "%3.2f",
  817.       "%.0f",
  818.       "%.1f",
  819. + 
  820. +     "%-1.5g",
  821. +     "%1.5g",
  822. +     "%123.9g",
  823. +     "%10.5g",
  824. +     "% 10.5g",
  825. +     "%+22.9g",
  826. +     "%+4.9g",
  827. +     "%01.3g",
  828. +     "%4g",
  829. +     "%3.1g",
  830. +     "%3.2g",
  831. +     "%.0g",
  832. +     "%.1g",
  833. + 
  834. +     "%-1.5e",
  835. +     "%1.5e",
  836. +     "%123.9e",
  837. +     "%10.5e",
  838. +     "% 10.5e",
  839. +     "%+22.9e",
  840. +     "%+4.9e",
  841. +     "%01.3e",
  842. +     "%4e",
  843. +     "%3.1e",
  844. +     "%3.2e",
  845. +     "%.0e",
  846. +     "%.1e",
  847. + 
  848.       NULL
  849.     };
  850.     double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
  851. ***************
  852. *** 908,912 ****
  853.       }
  854.     printf ("%d tests failed out of %d.\n", fail, num);
  855.   }
  856. ! #endif /* SNPRINTF_TEST */
  857.   
  858. --- 1110,1114 ----
  859.       }
  860.     printf ("%d tests failed out of %d.\n", fail, num);
  861.   }
  862. ! #endif /* TEST_SNPRINTF */
  863.   
  864. *** lib/smbrun.c    Tue Jul 20 22:25:09 1999
  865. --- /new/lib/smbrun.c    Mon May 22 18:36:17 2000
  866. ***************
  867. *** 91,96 ****
  868. --- 91,99 ----
  869.       set_process_capability(KERNEL_OPLOCK_CAPABILITY, False);
  870.       set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY, False);
  871.   
  872. + #ifdef AMIGA
  873. +     return(amiga_smbrun(cmd,outfile,shared));
  874. + #else
  875.   #ifndef HAVE_EXECL
  876.       int ret;
  877.       pstring syscmd;  
  878. ***************
  879. *** 195,198 ****
  880. --- 198,202 ----
  881.       exit(82);
  882.   #endif
  883.       return 1;
  884. + #endif /* AMIGA */
  885.   }
  886. *** lib/util.c    Tue Apr 25 20:06:53 2000
  887. --- /new/lib/util.c    Mon May 22 18:01:33 2000
  888. ***************
  889. *** 1517,1522 ****
  890. --- 1517,1529 ----
  891.   ****************************************************************************/
  892.   void become_daemon(void)
  893.   {
  894. +     #ifdef AMIGA
  895. +     {
  896. +         DEBUG(2,("Warning: become_daemon() not done.\n"));
  897. +         return;
  898. +     }
  899. +     #endif /* AMIGA */
  900. + 
  901.       if (fork()) {
  902.           _exit(0);
  903.       }
  904. *** lib/interface.c    Wed Oct 13 02:26:48 1999
  905. --- /new/lib/interface.c    Mon May 22 18:01:33 2000
  906. ***************
  907. *** 234,243 ****
  908.   
  909.       n = get_interfaces(ifaces, MAX_INTERFACES);
  910.   
  911. !     if (n != total_probed ||
  912. !         memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n)) {
  913. !         return True;
  914.       }
  915.       
  916.       return False;
  917.   }
  918. --- 234,255 ----
  919.   
  920.       n = get_interfaces(ifaces, MAX_INTERFACES);
  921.   
  922. !     /* olsen: probed_ifaces can be NULL! */
  923. !     #ifdef AMIGA
  924. !     {
  925. !         if (n != total_probed ||
  926. !             (probed_ifaces != NULL && memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) {
  927. !             return True;
  928. !         }
  929.       }
  930. +     #else
  931. +     {
  932. +         if (n != total_probed ||
  933. +             memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n)) {
  934. +             return True;
  935. +         }
  936. +     }
  937. +     #endif
  938.       
  939.       return False;
  940.   }
  941. *** lib/interfaces.c    Tue Apr 25 20:06:50 2000
  942. --- /new/lib/interfaces.c    Mon May 22 18:01:33 2000
  943. ***************
  944. *** 335,340 ****
  945. --- 335,349 ----
  946.       return total;
  947.   }
  948.   
  949. + #elif defined(AMIGA)
  950. + 
  951. + static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces)
  952. + {
  953. +     extern int amiga_get_interfaces(struct iface_struct * ifaces,int max_interfaces);
  954. + 
  955. +     return(amiga_get_interfaces(ifaces,max_interfaces));
  956. + }
  957. + 
  958.   #else /* a dummy version */
  959.   static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces)
  960.   {
  961. *** web/cgi.c    Tue Apr 25 20:07:17 2000
  962. --- /new/web/cgi.c    Mon May 22 18:49:31 2000
  963. ***************
  964. *** 198,204 ****
  965.       }
  966.   
  967.       fclose(stdin);
  968. !     (void)open("/dev/null", O_RDWR);
  969.   
  970.       if ((s=query_string) || (s=getenv("QUERY_STRING"))) {
  971.           for (tok=strtok(s,"&;");tok;tok=strtok(NULL,"&;")) {
  972. --- 198,209 ----
  973.       }
  974.   
  975.       fclose(stdin);
  976. ! 
  977. !     #ifndef AMIGA
  978. !     {
  979. !         (void)open("/dev/null", O_RDWR);
  980. !     }
  981. !     #endif /* AMIGA */
  982.   
  983.       if ((s=query_string) || (s=getenv("QUERY_STRING"))) {
  984.           for (tok=strtok(s,"&;");tok;tok=strtok(NULL,"&;")) {
  985. *** web/swat.c    Tue Apr 25 20:07:17 2000
  986. --- /new/web/swat.c    Mon May 22 18:01:38 2000
  987. ***************
  988. *** 980,987 ****
  989.       if (!dbf) dbf = stderr;
  990.   
  991.       /* we don't want stderr screwing us up */
  992. !     close(2);
  993. !     open("/dev/null", O_WRONLY);
  994.   
  995.       while ((opt = getopt(argc, argv,"s:a")) != EOF) {
  996.           switch (opt) {
  997. --- 980,991 ----
  998.       if (!dbf) dbf = stderr;
  999.   
  1000.       /* we don't want stderr screwing us up */
  1001. !     #ifndef AMIGA
  1002. !     {
  1003. !         close(2);
  1004. !         open("/dev/null", O_WRONLY);
  1005. !     }
  1006. !     #endif /* AMIGA */
  1007.   
  1008.       while ((opt = getopt(argc, argv,"s:a")) != EOF) {
  1009.           switch (opt) {
  1010. *** smbd/reply.c    Tue Apr 25 22:06:22 2000
  1011. --- /new/smbd/reply.c    Mon May 22 18:01:38 2000
  1012. ***************
  1013. *** 971,977 ****
  1014.       char *p;
  1015.       set_message(outbuf,3,3,True);
  1016.       p = smb_buf(outbuf);
  1017. !     pstrcpy(p,"Unix"); p = skip_string(p,1);
  1018.       pstrcpy(p,"Samba "); pstrcat(p,VERSION); p = skip_string(p,1);
  1019.       pstrcpy(p,global_myworkgroup); p = skip_string(p,1);
  1020.       set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
  1021. --- 971,985 ----
  1022.       char *p;
  1023.       set_message(outbuf,3,3,True);
  1024.       p = smb_buf(outbuf);
  1025. !     #ifdef AMIGA
  1026. !     {
  1027. !       pstrcpy(p,"AmigaOS"); p = skip_string(p,1);
  1028. !     }
  1029. !     #else
  1030. !     {
  1031. !       pstrcpy(p,"Unix"); p = skip_string(p,1);
  1032. !     }
  1033. !     #endif /* AMIGA */
  1034.       pstrcpy(p,"Samba "); pstrcat(p,VERSION); p = skip_string(p,1);
  1035.       pstrcpy(p,global_myworkgroup); p = skip_string(p,1);
  1036.       set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
  1037. *** passdb/smbpass.c    Tue Apr 25 20:07:01 2000
  1038. --- /new/passdb/smbpass.c    Mon May 22 18:53:19 2000
  1039. ***************
  1040. *** 148,161 ****
  1041.     /* Set a buffer to do more efficient reads */
  1042.     setvbuf(fp, (char *)NULL, _IOFBF, 1024);
  1043.   
  1044.     /* Make sure it is only rw by the owner */
  1045. !   if(fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
  1046. !     DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
  1047.   Error was %s\n.", pfile, strerror(errno) ));
  1048. !     pw_file_unlock(fileno(fp), lock_depth);
  1049. !     fclose(fp);
  1050. !     return NULL;
  1051.     }
  1052.   
  1053.     /* We have a lock on the file. */
  1054.     return (void *)fp;
  1055. --- 148,165 ----
  1056.     /* Set a buffer to do more efficient reads */
  1057.     setvbuf(fp, (char *)NULL, _IOFBF, 1024);
  1058.   
  1059. +   #ifndef AMIGA
  1060. +   {
  1061.     /* Make sure it is only rw by the owner */
  1062. !     if(fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
  1063. !       DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
  1064.   Error was %s\n.", pfile, strerror(errno) ));
  1065. !       pw_file_unlock(fileno(fp), lock_depth);
  1066. !       fclose(fp);
  1067. !       return NULL;
  1068. !     }
  1069.     }
  1070. +   #endif /* AMIGA */
  1071.   
  1072.     /* We have a lock on the file. */
  1073.     return (void *)fp;
  1074. *** include/includes.h    Tue Apr 25 20:06:46 2000
  1075. --- /new/include/includes.h    Mon May 22 18:01:26 2000
  1076. ***************
  1077. *** 21,26 ****
  1078. --- 21,36 ----
  1079.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1080.   */
  1081.   
  1082. + #ifdef AMIGA
  1083. + /* This type definition clashes with one
  1084. +  * used in the Samba code, which is why
  1085. +  * we hide it.
  1086. +  */
  1087. + #define BOOL __BOOL
  1088. + #include <exec/types.h>
  1089. + #undef BOOL
  1090. + #endif /* AMIGA */
  1091. + 
  1092.   #ifndef NO_CONFIG_H /* for some tests */
  1093.   #include "config.h"
  1094.   #endif
  1095. ***************
  1096. *** 880,885 ****
  1097. --- 890,906 ----
  1098.   
  1099.   /* yuck, I'd like a better way of doing this */
  1100.   #define DIRP_SIZE (256 + 32)
  1101. + 
  1102. + #ifdef AMIGA
  1103. + /* Remap a couple of library routines. */
  1104. + #include "amiga.h"
  1105. + 
  1106. + /* These clash with local definitions in "smbd/ipc.c",
  1107. +  * which is why we undefine them.
  1108. +  */
  1109. + #undef ACCESS_READ
  1110. + #undef ACCESS_WRITE
  1111. + #endif /* AMIGA */
  1112.   
  1113.   /*
  1114.    * glibc on linux doesn't seem to have MSG_WAITALL
  1115. *** libsmb/clientgen.c    Tue Apr 25 20:06:54 2000
  1116. --- /new/libsmb/clientgen.c    Mon May 22 18:01:36 2000
  1117. ***************
  1118. *** 876,882 ****
  1119.           pstrcpy(p,workgroup);
  1120.           strupper(p);
  1121.           p = skip_string(p,1);
  1122. !         pstrcpy(p,"Unix");p = skip_string(p,1);
  1123.           pstrcpy(p,"Samba");p = skip_string(p,1);
  1124.           set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
  1125.       }
  1126. --- 876,890 ----
  1127.           pstrcpy(p,workgroup);
  1128.           strupper(p);
  1129.           p = skip_string(p,1);
  1130. !         #ifdef AMIGA
  1131. !         {
  1132. !           pstrcpy(p,"AmigaOS");p = skip_string(p,1);
  1133. !         }
  1134. !         #else
  1135. !         {
  1136. !           pstrcpy(p,"Unix");p = skip_string(p,1);
  1137. !         }
  1138. !         #endif /* AMIGA */
  1139.           pstrcpy(p,"Samba");p = skip_string(p,1);
  1140.           set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
  1141.       }
  1142. *** utils/testparm.c    Wed Oct 13 02:27:03 1999
  1143. --- /new/utils/testparm.c    Thu Aug 17 14:42:14 2000
  1144. ***************
  1145. *** 70,78 ****
  1146.                  lp_lockdir());
  1147.           ret = 1;
  1148.       } else if ((st.st_mode & 0777) != 0755) {
  1149. !         printf("WARNING: lock directory %s should have permissions 0755 for browsing to work\n",
  1150. !                lp_lockdir());
  1151. !         ret = 1;
  1152.       }
  1153.   
  1154.       /*
  1155. --- 70,88 ----
  1156.                  lp_lockdir());
  1157.           ret = 1;
  1158.       } else if ((st.st_mode & 0777) != 0755) {
  1159. !         /* olsen: This is not necessary on the Amiga and always
  1160. !          *        seems to be a source of confusion when users
  1161. !          *        try to determine what's wrong with their
  1162. !          *        configurations.
  1163. !          */
  1164. ! 
  1165. !         #ifndef AMIGA
  1166. !         {
  1167. !             printf("WARNING: lock directory %s should have permissions 0755 for browsing to work\n",
  1168. !                    lp_lockdir());
  1169. !             ret = 1;
  1170. !         }
  1171. !         #endif /* AMIGA */
  1172.       }
  1173.   
  1174.       /*
  1175.